/**
 * step1：可达到 简易的 派单  2023年9月13日16:01:24 已基本达到
 * step2：完成消息通知细节 前端能够达到接收消息自由
 * step3：完成下单限制，取消下单。增加限制
 */

const express=require('express');
const http = require('http');
const socketIo=require('socket.io');
// -------------数据库 原代码-----------
//https://www.sequelize.cn/core-concepts/model-basics
// const { Sequelize, DataTypes } = require('sequelize');
// const uuid=require('uuid');// 生成唯一标识
//--------------封装抽离----------------

const app = express();
const server = http.Server(app);
const io=socketIo(server, {
    cors: true,
});


app.use(cors());

// 静态部署
// app.get('/', (req, res) => {
//   res.sendFile(__dirname + '/index.html');
// });

const online= new Set()
io.on('connection', (socket) => {
    console.log('新进入',socket.id);
    online.add(socket)
    // 抢单任务对列
    const orderQueue = async.queue(async (order, callback) => {
        const t = await sequelize.transaction(); // 创建数据库事务
    
        try {
          const existingOrder = await Order.findOne({
            where: {
              id: order.id,
              is_accepted: false,
            },
            transaction: t, // 使用事务
            lock: true,
          });
    
          if (existingOrder) {
            await existingOrder.update({ is_accepted: true }, { transaction: t });
    
            await OperationLog.create({
              user_id: order.user_id,
              action: 'Order Accepted',
              order_id: order.id,
            }, { transaction: t });
    
            socket.emit('order-accepted', order.id);
          } else {
            socket.emit('order-rejected', order.id);
          }
    
          await t.commit(); // 提交事务
          callback();
        } catch (error) {
          console.error(error);
          await t.rollback(); // 如果出错，回滚事务
          callback();
        }
      }, 1);


  socket.on('order-request', async (order) => {
      
    console.log('创建前的order',order);
    const t = await db.transaction(); // 创建数据库事务

    try {
      // 创建新订单
      const newOrder = await Order.create(order);

      // 记录订单创建操作
      await OperationLog.create({
        user_id: order.user_id,
        action: 'Order Created',
        order_id: newOrder.id,
      });

      // 告知所有连接的司机有新订单
      io.emit('new-order', newOrder);

      // 判断是否有其他司机已经抢到该订单
      const existingOrder = await Order.findOne({
        where: {
          id: newOrder.id,
          is_accepted: 1,
          },
          transaction: t, // 在事务中进行查询
          lock: true, // 使用排他锁
      });

        if(!existingOrder) {
        // 告知当前用户抢单成功 // 这有待改进
        socket.emit('order-accepted', newOrder.id);

        // 更新订单状态为已接受
        await newOrder.update({ is_accepted: 1 },{ transaction: t });

        // 记录订单接受操作
        await OperationLog.create({
          user_id: order.user_id,
          action: 'Order Accepted',
          order_id: newOrder.id,
        }, { transaction: t });
        await t.commit();

        } else {
        // 回滚事务 释放状态
        await t.rollback();
        // 告知当前用户抢单失败
        socket.emit('order-rejected', newOrder.id);
      }
    } catch (error) {
        console.error(error);
        await t.rollback();
    }
    });
    // 司机接收端


    
    socket.on('driver-request', async (orderId) => {
        lock.acquire(orderId, async () => {
          orderQueue.push({ id: orderId, user_id: 'Driver' });
          const order = await Order.findByPk(orderId);
      
          if (order && order.is_accepted) {
            // 告知当前司机抢单成功
            // socket.emit('driver-order-accepted', orderId);
      
            // 发送抢单成功通知给司机
            socket.emit('driver-notification', {status:1,data:order});
          } else {
            // 发送抢单失败通知给司机
            socket.emit('driver-notification', {status:0,data:null});
          }
        });
      });

// 离线清除
  socket.on('disconnect', (e) => {
      console.log('一位用户已离开',e);
      online.delete(socket);
  });
});
server.listen(port, () => {
    console.log(`Server is running on port http://localhost${port}`);
});
